hex_lit 0.1.1

Hex macro literals without use of hex macros
Documentation

Hex literals without proc macros.

This crate implements minimalistic hex literal macros without use of proc macros. The advantages are much faster compile times, ability to work with non-literal const values and easier auditing. However, because of the use of const fn the crate has some limitations depending on the Rust version.

Either way, the resulting type is a byte array ([u8; N]) that doesn't force you to write down its length. This is already very useful since the compiler can prove the length and you avoid runtime allocations.

The crate is no_std and does not require an allocator.

Usage

Just pass a &str constant (usually a literal) into the hex macro.

Example

use hex_lit::hex;

let array = hex!("2a15ff");
assert_eq!(&array, &[42, 21, 255]);

The input MUST NOT contain any spaces or other separators and it MUST have even length. Note that you can still separate long strings into chunks using the concat macro:

use hex_lit::hex;

let array = hex!(concat!(
    "0000002a000000",
    "ffffffffffffff",
));
assert_eq!(&array, &[0, 0, 0, 42, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255]);

Features depending on Rust version

  • 1.41.1+ - the MSRV, use in const contexts is impossible, only the hex! macro is available.
  • 1.46.0+ - usage in const contexts is available and (regardless of cargo features) correctness of input is checked at compile time.
  • 1.57+ - nicer error messages for bad inputs (regardless of cargo features)

Cargo features

  • rust_v_1_46 - acknowledges bumping MSRV to 1.46+ and enables usage in const context.

Bumping MSRV is intentionally explicit.

Because of improved input checking it is recommended to use Rust 1.46+, prefereably 1.57+ in CI even if your targeted MSRV is lower.

License

MITNFA